{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Example: Image segmentation using customized UNET 3+ and hybrid loss"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "import numpy as np\n",
    "from glob import glob"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "from tensorflow import keras\n",
    "from tensorflow.keras.layers import Input, Conv2D, Dropout, Activation, UpSampling2D, GlobalMaxPooling2D, multiply\n",
    "from tensorflow.keras.backend import max"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "This example requires `keras-unet-collection==0.1.6` or higher:\n",
    "```\n",
    "pip install keras-unet-collection\n",
    "```"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "from keras_unet_collection import models, base, utils"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [],
   "source": [
    "# the indicator of a fresh run\n",
    "first_time_running = False\n",
    "\n",
    "# user-specified working directory\n",
    "filepath = '/system/drive/oxford_iiit/'"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## The Oxford-IIIT Pets dataset\n",
    "\n",
    "This example applies the dataset of [Oxford-IIIT Pet Dataset](https://www.robots.ox.ac.uk/~vgg/data/pets/) (Parkhi et al. 2012). This dataset contains images of pets and their pixel-wise mask that indicates (1) pixels belonging to the pet, (2) pixels bordering the pet, and (3) surrounding pixels.\n",
    "\n",
    "The Oxford-IIIT Pets dataset will be downloaded and unpacked through the cell blow."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [],
   "source": [
    "if first_time_running:\n",
    "    # downloading and executing data files\n",
    "    import tarfile\n",
    "    import urllib.request\n",
    "    \n",
    "    filename_image = filepath+'images.tar.gz'\n",
    "    filename_target = filepath+'annotations.tar.gz'\n",
    "    \n",
    "    urllib.request.urlretrieve('http://www.robots.ox.ac.uk/~vgg/data/pets/data/images.tar.gz', filename_image);\n",
    "    urllib.request.urlretrieve('https://www.robots.ox.ac.uk/~vgg/data/pets/data/annotations.tar.gz', filename_target);\n",
    "    \n",
    "    with tarfile.open(filename_image, \"r:gz\") as tar_io:\n",
    "        tar_io.extractall(path=filepath)\n",
    "    with tarfile.open(filename_target, \"r:gz\") as tar_io:\n",
    "        tar_io.extractall(path=filepath)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Customizing a segmentation model based on UNET 3+\n",
    "\n",
    "In this example, an image segmentation model is proposed to classify the pixel mask by taking the re-sized RGB images as inputs.\n",
    "\n",
    "The architecture of UNET 3+ is applied in this segmentation task. UNET 3+ is a convolutional neural network with encoder-decoder blocks, similar to the conventionally used Unet, and with technical highlights of full-scale skip connections, deep supervision, and classification-guided module (CGM). In Huang et al. (2020), UNET 3+ overperformed Unet and Unet++ in the dataset of ISBI LiTS 2017 Challenge.\n",
    "\n",
    "We specify five downsampling blocks with the number of convolution filters grows from 32 to 512. Each downsampling level consists of two convolutional layers. The upsampling block of UNET 3+ features a full-scale skip connection of five input tensors, and each tensor is originated from a different down-/upsampling level. Within the upsampling block, each input tensor is processed by a convolutional layer with 32 filters ( `filter_num_skip=32` ), then concatenated, and passed through another convolutional layer with 160 filters ( `filter_num_aggregate=160` ). The resulting tensors are collected and fed into either the next upsampling block or the output section. \n",
    "\n",
    "The code cell below configures the base architecture of this segmentation model. The input size is fixed to 128-by-128. Batch normalization is applied after each of the convolutional layers. Down- and upsampling are achieved through maxpooling and bilinear interpolation, respectively.\n",
    "\n",
    "Further use case of `base.unet_3plus_2d_base` is available through its Python helper function:\n",
    "\n",
    "```python\n",
    "from keras_unet_collection import models\n",
    "\n",
    "help(base.unet_3plus_2d_base)\n",
    "```"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [],
   "source": [
    "name = 'unet3plus'\n",
    "activation = 'ReLU'\n",
    "filter_num_down = [32, 64, 128, 256, 512]\n",
    "filter_num_skip = [32, 32, 32, 32]\n",
    "filter_num_aggregate = 160\n",
    "\n",
    "stack_num_down = 2\n",
    "stack_num_up = 1\n",
    "n_labels = 3\n",
    "\n",
    "# `unet_3plus_2d_base` accepts an input tensor \n",
    "# and produces output tensors from different upsampling levels\n",
    "# ---------------------------------------- #\n",
    "input_tensor = keras.layers.Input((128, 128, 3))\n",
    "# base architecture\n",
    "X_decoder = base.unet_3plus_2d_base(\n",
    "    input_tensor, filter_num_down, filter_num_skip, filter_num_aggregate, \n",
    "    stack_num_down=stack_num_down, stack_num_up=stack_num_up, activation=activation, \n",
    "    batch_norm=True, pool=True, unpool=True, backbone=None, name=name)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The collected feature maps as four-dimensional tensors of (sample number, width, height, channel) are shown as follows:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[<KerasTensor: shape=(None, 8, 8, 512) dtype=float32 (created by layer 'unet3plus_down4_conv_1_activation')>,\n",
       " <KerasTensor: shape=(None, 16, 16, 160) dtype=float32 (created by layer 'unet3plus_fusion_conv_0_0_activation')>,\n",
       " <KerasTensor: shape=(None, 32, 32, 160) dtype=float32 (created by layer 'unet3plus_fusion_conv_1_0_activation')>,\n",
       " <KerasTensor: shape=(None, 64, 64, 160) dtype=float32 (created by layer 'unet3plus_fusion_conv_2_0_activation')>,\n",
       " <KerasTensor: shape=(None, 128, 128, 160) dtype=float32 (created by layer 'unet3plus_fusion_conv_3_0_activation')>]"
      ]
     },
     "execution_count": 7,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "X_decoder"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Deep supervision**\n",
    "\n",
    "The output section of UNET 3+ consists of deep-supervision and Classification-Guided Module (CGM).\n",
    "\n",
    "Deep-supervision upsamples intermediate feature maps to full-resolution and enables the back-propagation of training loss from these full-resolution branches. Based on Huang et al. (2020). The deep-supervision branch of UNET 3+ consists of 3-by-3 convolutional layers followed by bilinear-interpolation-based upsampling and sigmoid output activation.\n",
    "\n",
    "The code cell below constructs deep-supervision branches. Alternatively, `keras_unet_collection.models.unet_3plus_2d` with `deep_supervision=True` would produce the same keras model."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [],
   "source": [
    "# allocating deep supervision tensors\n",
    "OUT_stack = []\n",
    "# reverse indexing `X_decoder`, so smaller tensors have larger list indices \n",
    "X_decoder = X_decoder[::-1]\n",
    "\n",
    "# deep supervision outputs\n",
    "for i in range(1, len(X_decoder)):\n",
    "    # 3-by-3 conv2d --> upsampling --> sigmoid output activation\n",
    "    pool_size = 2**(i)\n",
    "    X = Conv2D(n_labels, 3, padding='same', name='{}_output_conv1_{}'.format(name, i-1))(X_decoder[i])\n",
    "    \n",
    "    X = UpSampling2D((pool_size, pool_size), interpolation='bilinear', \n",
    "                     name='{}_output_sup{}'.format(name, i-1))(X)\n",
    "    \n",
    "    X = Activation('sigmoid', name='{}_output_sup{}_activation'.format(name, i-1))(X)\n",
    "    # collecting deep supervision tensors\n",
    "    OUT_stack.append(X)\n",
    "\n",
    "# the final output (without extra upsampling)\n",
    "# 3-by-3 conv2d --> sigmoid output activation\n",
    "X = Conv2D(n_labels, 3, padding='same', name='{}_output_final'.format(name))(X_decoder[0])\n",
    "X = Activation('sigmoid', name='{}_output_final_activation'.format(name))(X)\n",
    "# collecting final output tensors\n",
    "OUT_stack.append(X)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The deep-supervision and final output tensors are shown as follows:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[<KerasTensor: shape=(None, 128, 128, 3) dtype=float32 (created by layer 'unet3plus_output_sup0_activation')>,\n",
       " <KerasTensor: shape=(None, 128, 128, 3) dtype=float32 (created by layer 'unet3plus_output_sup1_activation')>,\n",
       " <KerasTensor: shape=(None, 128, 128, 3) dtype=float32 (created by layer 'unet3plus_output_sup2_activation')>,\n",
       " <KerasTensor: shape=(None, 128, 128, 3) dtype=float32 (created by layer 'unet3plus_output_sup3_activation')>,\n",
       " <KerasTensor: shape=(None, 128, 128, 3) dtype=float32 (created by layer 'unet3plus_output_final_activation')>]"
      ]
     },
     "execution_count": 9,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "OUT_stack"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Classification-guided Module (CGM)**\n",
    "\n",
    "Huang et al. (2020) proposed CGM for handling the over-segmentation problem. CGM takes the output tensor of the deepest downsampling level, and converts it into a *single value* that indicates the probability of the existence of the segmentation target.\n",
    "\n",
    "The code cell below adds CGM into the existing deep-supervision branches.\n",
    "\n",
    "**Note**\n",
    "\n",
    "The CGM value is not trained separately in this example. \n",
    "\n",
    "In Huang et al. (2020), the CGM is trained with \"none-organ images\". This is not explicitly available in the Oxford-IIIT dataset."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Classification-guided Module (CGM)\n",
    "# ---------------------------------------- #\n",
    "# dropout --> 1-by-1 conv2d --> global-maxpooling --> sigmoid\n",
    "X_CGM = X_decoder[-1]\n",
    "X_CGM = Dropout(rate=0.1)(X_CGM)\n",
    "X_CGM = Conv2D(filter_num_skip[-1], 1, padding='same')(X_CGM)\n",
    "X_CGM = GlobalMaxPooling2D()(X_CGM)\n",
    "X_CGM = Activation('sigmoid')(X_CGM)\n",
    "\n",
    "CGM_mask = max(X_CGM, axis=-1) # <----- This value could be trained with \"none-organ image\"\n",
    "\n",
    "for i in range(len(OUT_stack)):\n",
    "    if i < len(OUT_stack)-1:\n",
    "        # deep-supervision\n",
    "        OUT_stack[i] = multiply([OUT_stack[i], CGM_mask], name='{}_output_sup{}_CGM'.format(name, i))\n",
    "    else:\n",
    "        # final output\n",
    "        OUT_stack[i] = multiply([OUT_stack[i], CGM_mask], name='{}_output_final_CGM'.format(name))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[<KerasTensor: shape=(None, 128, 128, 3) dtype=float32 (created by layer 'unet3plus_output_sup0_CGM')>,\n",
       " <KerasTensor: shape=(None, 128, 128, 3) dtype=float32 (created by layer 'unet3plus_output_sup1_CGM')>,\n",
       " <KerasTensor: shape=(None, 128, 128, 3) dtype=float32 (created by layer 'unet3plus_output_sup2_CGM')>,\n",
       " <KerasTensor: shape=(None, 128, 128, 3) dtype=float32 (created by layer 'unet3plus_output_sup3_CGM')>,\n",
       " <KerasTensor: shape=(None, 128, 128, 3) dtype=float32 (created by layer 'unet3plus_output_final_CGM')>]"
      ]
     },
     "execution_count": 11,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "OUT_stack"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Compiling the segmentation model**\n",
    "\n",
    "The segmentation model is trained with cross-entropy loss. Each deep-supervision branch contributes 12.5% of the total loss value, whereas the final output loss contribution is 50%. The Adam optimizer with a learning rate of 1E-4 is applied."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [],
   "source": [
    "# executing all the above cells in one time to avoid dupilcated tensor names.\n",
    "unet3plus = keras.models.Model([input_tensor,], OUT_stack)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Hybrid loss**\n",
    "\n",
    "The hybrid loss function, as suggested in Huang et al. (2020) is implemented.\n",
    "\n",
    "**Note** \n",
    "\n",
    "* The MS-SSMI loss is found lack of robustness in training, likely becuase of the hard-labeled binary target.\n",
    "\n",
    "* The focal loss is replaced by the focal Tversky loss."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [],
   "source": [
    "from keras_unet_collection import losses\n",
    "\n",
    "def hybrid_loss(y_true, y_pred):\n",
    "\n",
    "    loss_focal = losses.focal_tversky(y_true, y_pred, alpha=0.5, gamma=4/3)\n",
    "    loss_iou = losses.iou_seg(y_true, y_pred)\n",
    "    \n",
    "    # (x) \n",
    "    #loss_ssim = losses.ms_ssim(y_true, y_pred, max_val=1.0, filter_size=4)\n",
    "    \n",
    "    return loss_focal+loss_iou #+loss_ssim"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "This hybrid loss is applied for deep supervisions and the final pridction:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [],
   "source": [
    "unet3plus.compile(loss=[hybrid_loss, hybrid_loss, hybrid_loss, hybrid_loss, hybrid_loss],\n",
    "                  loss_weights=[0.25, 0.25, 0.25, 0.25, 1.0],\n",
    "                  optimizer=keras.optimizers.Adam(learning_rate=1e-4))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Data pre-processing\n",
    "\n",
    "The input of RGB images are resized to 128-by-128 through the nearest neighbour scheme, and then normalized to the interval of [0, 1]. The training target of pixel-wise masks are resized similarly.\n",
    "\n",
    "A random split is applied with 80%, 10%, 10% of the samples are assigned for training, validation, and testing, respectively."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [],
   "source": [
    "def input_data_process(input_array):\n",
    "    '''converting pixel vales to [0, 1]'''\n",
    "    return input_array/255.\n",
    "\n",
    "def target_data_process(target_array):\n",
    "    '''Converting tri-mask of {1, 2, 3} to three categories.'''\n",
    "    return keras.utils.to_categorical(target_array-1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Training:validation:testing = 5881:735:736\n"
     ]
    }
   ],
   "source": [
    "sample_names = np.array(sorted(glob(filepath+'images/*.jpg')))\n",
    "label_names = np.array(sorted(glob(filepath+'annotations/trimaps/*.png')))\n",
    "\n",
    "L = len(sample_names)\n",
    "ind_all = utils.shuffle_ind(L)\n",
    "\n",
    "L_train = int(0.8*L); L_valid = int(0.1*L); L_test = L - L_train - L_valid\n",
    "ind_train = ind_all[:L_train]; ind_valid = ind_all[L_train:L_train+L_valid]; ind_test = ind_all[L_train+L_valid:]\n",
    "print(\"Training:validation:testing = {}:{}:{}\".format(L_train, L_valid, L_test))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [],
   "source": [
    "valid_input = input_data_process(utils.image_to_array(sample_names[ind_valid], size=128, channel=3))\n",
    "valid_target = target_data_process(utils.image_to_array(label_names[ind_valid], size=128, channel=1))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [],
   "source": [
    "test_input = input_data_process(utils.image_to_array(sample_names[ind_test], size=128, channel=3))\n",
    "test_target = target_data_process(utils.image_to_array(label_names[ind_test], size=128, channel=1))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Training\n",
    "\n",
    "The segmentation model is trained with fixed 10 epoches. Each epoch containts 100 batches and each batch contains 32 samples.\n",
    "\n",
    "*The training process here is far from systematic, and is provided for illustration purposes only.*"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\tInitial loss = 1.6054073572158813\n",
      "Validation performance is improved from 1.6054073572158813 to 1.136747121810913\n",
      "Validation performance is improved from 1.136747121810913 to 0.9474636316299438\n",
      "Validation performance is improved from 0.9474636316299438 to 0.7545518279075623\n",
      "Validation performance is improved from 0.7545518279075623 to 0.6593649387359619\n",
      "Validation performance is improved from 0.6593649387359619 to 0.5839570164680481\n",
      "Validation performance is improved from 0.5839570164680481 to 0.5225192308425903\n",
      "Validation performance is improved from 0.5225192308425903 to 0.5102208852767944\n",
      "Validation performance 0.5260202884674072 is NOT improved\n",
      "Validation performance is improved from 0.5102208852767944 to 0.48606806993484497\n",
      "Validation performance is improved from 0.48606806993484497 to 0.47382062673568726\n"
     ]
    }
   ],
   "source": [
    "N_epoch = 10 # number of epoches\n",
    "N_batch = 100 # number of batches per epoch\n",
    "N_sample = 32 # number of samples per batch\n",
    "\n",
    "tol = 0 # current early stopping patience\n",
    "max_tol = 3 # the max-allowed early stopping patience\n",
    "min_del = 0 # the lowest acceptable loss value reduction \n",
    "\n",
    "# loop over epoches\n",
    "for epoch in range(N_epoch):\n",
    "    \n",
    "    # initial loss record\n",
    "    if epoch == 0:\n",
    "        temp_out = unet3plus.predict([valid_input])\n",
    "        y_pred = temp_out[-1]\n",
    "        record = np.mean(hybrid_loss(valid_target, y_pred))\n",
    "        print('\\tInitial loss = {}'.format(record))\n",
    "    \n",
    "    # loop over batches\n",
    "    for step in range(N_batch):\n",
    "        # selecting smaples for the current batch\n",
    "        ind_train_shuffle = utils.shuffle_ind(L_train)[:N_sample]\n",
    "        \n",
    "        # batch data formation\n",
    "        ## augmentation is not applied\n",
    "        train_input = input_data_process(\n",
    "            utils.image_to_array(sample_names[ind_train][ind_train_shuffle], size=128, channel=3))\n",
    "        train_target = target_data_process(\n",
    "            utils.image_to_array(label_names[ind_train][ind_train_shuffle], size=128, channel=1))\n",
    "        \n",
    "        # train on batch\n",
    "        loss_ = unet3plus.train_on_batch([train_input,], \n",
    "                                         [train_target, train_target, train_target, train_target, train_target,])\n",
    "#         if np.isnan(loss_):\n",
    "#             print(\"Training blow-up\")\n",
    "\n",
    "        # ** training loss is not stored ** #\n",
    "        \n",
    "    # epoch-end validation\n",
    "    temp_out = unet3plus.predict([valid_input])\n",
    "    y_pred = temp_out[-1]\n",
    "    record_temp = np.mean(hybrid_loss(valid_target, y_pred))\n",
    "    # ** validation loss is not stored ** #\n",
    "    \n",
    "    # if loss is reduced\n",
    "    if record - record_temp > min_del:\n",
    "        print('Validation performance is improved from {} to {}'.format(record, record_temp))\n",
    "        record = record_temp; # update the loss record\n",
    "        tol = 0; # refresh early stopping patience\n",
    "        # ** model checkpoint is not stored ** #\n",
    "\n",
    "    # if loss not reduced\n",
    "    else:\n",
    "        print('Validation performance {} is NOT improved'.format(record_temp))\n",
    "        tol += 1\n",
    "        if tol >= max_tol:\n",
    "            print('Early stopping')\n",
    "            break;\n",
    "        else:\n",
    "            # Pass to the next epoch\n",
    "            continue;"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Evaluation\n",
    "\n",
    "The testing set performance is evaluated."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [],
   "source": [
    "temp_out = unet3plus.predict([test_input,])\n",
    "y_pred = temp_out[-1]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Testing set cross-entropy loss = 1.085909128189087\n",
      "Testing set focal Tversky loss = 0.23021744191646576\n",
      "Testing set IoU loss = 0.24730056524276733\n"
     ]
    }
   ],
   "source": [
    "print('Testing set cross-entropy loss = {}'.format(np.mean(keras.losses.categorical_crossentropy(test_target, y_pred))))\n",
    "print('Testing set focal Tversky loss = {}'.format(np.mean(losses.focal_tversky(test_target, y_pred))))\n",
    "print('Testing set IoU loss = {}'.format(np.mean(losses.iou_seg(test_target, y_pred))))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Example of outputs**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [],
   "source": [
    "import matplotlib.pyplot as plt\n",
    "%matplotlib inline"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [],
   "source": [
    "def ax_decorate_box(ax):\n",
    "    [j.set_linewidth(0) for j in ax.spines.values()]\n",
    "    ax.tick_params(axis=\"both\", which=\"both\", bottom=False, top=False, \n",
    "                   labelbottom=False, left=False, right=False, labelleft=False)\n",
    "    return ax"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 936x230.4 with 4 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "i_sample = 2\n",
    "\n",
    "fig, AX = plt.subplots(1, 4, figsize=(13, (13-0.2)/4))\n",
    "plt.subplots_adjust(0, 0, 1, 1, hspace=0, wspace=0.1)\n",
    "for ax in AX:\n",
    "    ax = ax_decorate_box(ax)\n",
    "AX[0].pcolormesh(np.mean(test_input[i_sample, ...,], axis=-1), cmap=plt.cm.gray)\n",
    "AX[1].pcolormesh(y_pred[i_sample, ..., 0], cmap=plt.cm.jet)\n",
    "AX[2].pcolormesh(y_pred[i_sample, ..., 1], cmap=plt.cm.jet)\n",
    "AX[3].pcolormesh(y_pred[i_sample, ..., 2], cmap=plt.cm.jet)\n",
    "\n",
    "AX[0].set_title(\"Original\", fontsize=14);\n",
    "AX[1].set_title(\"Pixels belong to the object\", fontsize=14);\n",
    "AX[2].set_title(\"Surrounding pixels\", fontsize=14);\n",
    "AX[3].set_title(\"Bordering pixels\", fontsize=14);"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Discussion\n",
    "\n",
    "A segmentation model is proposed based on the architecture of UNET 3+ and is trained using the Oxford-IIIT Pets dataset. Evaluation result indicates that this segmentation model can distinguish pixes of a pet from its backgrounds.\n",
    "\n",
    "Many technical details of this work, e.g., network hyper-parameters and training strategy, can be improved for achieving better performance. "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Reference**\n",
    "\n",
    "* Parkhi, O.M., Vedaldi, A., Zisserman, A. and Jawahar, C.V., 2012. Cats and dogs. In 2012 IEEE conference on computer vision and pattern recognition (pp. 3498-3505). IEEE.\n",
    "\n",
    "* Huang, H., Lin, L., Tong, R., Hu, H., Zhang, Q., Iwamoto, Y., Han, X., Chen, Y.W. and Wu, J., 2020. UNet 3+: A Full-Scale Connected UNet for Medical Image Segmentation. In ICASSP 2020-2020 IEEE International Conference on Acoustics, Speech and Signal Processing (ICASSP) (pp. 1055-1059). IEEE."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.6.8"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}
